|
一、String类
String的实例化方式
通过字面量定义的方式
String str = "hello world";
通过new+构造器的方式
String str = new String("hello world");
面试题：String s = new String("asf");方式创建对象，在内存中创建了几个对象？
答：两个，一个是堆空间中new出来的，一个是char[ ]对应的常量池中的数据：“abc”
String类的内部细节
String表示字符串，使用一对“”引起来表示
String声明为final，不可被继承
String实现了Serializable接口，表示字符串是支持序列化的；实现了Comparable接口，表示String是可以比较大小的
String内部定义了final char[ ] value 用于存储字符串数据
String代表不可变的字符序列，简称：不可变性💦体现在如下三个方面
①对字符串重新赋值时，需要重新指定内存区域赋值，不能使用原有的value进行赋值
②当对现有字符串进行连接操作时，也需要重新指定内存区域，不能对原有的value进行赋值
③当调用String的replace方法修改指定字符或者字符串时，也需要重新指定内存区域
通过字面量的方式（区别于new）给一个字符串赋值，此时的字符串声明在字符串常量池中
字符串常量池中是不会存储相同的字符串的
String赋值的各种内存结构
String的部分构造器源码（用于辅助理解其不可变性以及两种初始化方式）
public final class String
implements java.io.Serializable, Comparable, CharSequence {
/** The value is used for character storage. */
private final char value[];
/**
* Initializes a newly created {@code String} object so that it represents
* an empty character sequence. Note that use of this constructor is
* unnecessary since Strings are immutable.
*/
public String() {
this.value = "".value;
}
/**
* Initializes a newly created {@code String} object so that it represents
* the same sequence of characters as the argument; in other words, the
* newly created string is a copy of the argument string. Unless an
* explicit copy of {@code original} is needed, use of this constructor is
* unnecessary since Strings are immutable.
*
* @param original
* A {@code String}
*/
public String(String original) {
this.value = original.value;
this.hash = original.hash;
}
/**
* Allocates a new {@code String} so that it represents the sequence of
* characters currently contained in the character array argument. The
* contents of the character array are copied; subsequent modification of
* the character array does not affect the newly created string.
*
* @param value
* The initial value of the string
*/
public String(char value[]) {
this.value = Arrays.copyOf(value, value.length); //见如上注释，copy的目的是对于数组的操作不会影响String的值
}
}
例子
public class StringTest1 {
public static void main(String[] args) {
String str1="abc";
String str2="abc";
String str3=new String("abc");
String str4=new String("def");
System.out.println(str1==str2);
System.out.println(str1==str3);
}
}
内存结构图
（现在的知识有限，具体的细节我也不太懂，比如我不知道常量池里放的是否是对象，他们和数组的关系是不是应该这样放，我是按照视频里老师讲的和源码，自己理解为这样的，有错的话希望帮忙指出）
String的常用操作
连接字符串（+）
String s1="hello";
String s2="world";
String s3="hello"+"world";
String s4=s1+"world";
String s5=s1+s2;
String s6=(s1+s2).intern();
System.out.println(s3==s4);
System.out.println(s3==s5);
System.out.println(s4==s5);
System.out.println(s3==s6);
注意事项：
①常量与常量的拼接结果放在常量池中，且常量池中不会存在相同内容的常量
②只要其中一个是变量，结果就在堆中
③如果拼接的结果调用intern方法，返回值就在常量池中
题目：
final String str="123";
String str1=str+"abc";
String str2="123abc";
System.out.println(str1==str2); //true
解释：此时的str是常量，参照①
int length() 输出数组的长度，实际上是底层的数组的长度
char chatAt(int index) 返回index索引处的字符，实际上是return value[index];
🙊区别于C++的可以对字符串按照字符数组的方式进行访问修改，在java中，字符串是对象，应该使用对象的方法对字符串进行访问、修改等操作
boolean isEmpty() 判断当前数组是否为空，return value.length==0;
String toLowerCase() / toUpperCase() 将字符都变为小写或大写
String str1="ASDFG";
String str2=str1.toLowerCase();
//str1不变，印证了String的不变性
System.out.println(str1);
System.out.println(str2);
String trim() 返回值是去除原字符串首尾空格的副本，原字符串不变
boolean equals(Object obj) 比较字符串的内容是否相同
boolean equalsIgnoreCase(Object obj) 忽略大小写比较
String concat(String str) 将指定字符串连接到此字符串的结尾，等价于“+”
int compareTo(String str) 比较两个字符串的大小 负数，则当前对象小；整数，则str小
String substring(int beginIndex) 返回一个新的字符串，该字符串是从beginIndex开始截取到最后
String substring(int beginIndex, int endIndex) 返回一个新的字符串，该字符串是从beginIndex开始截取到endIndex-1的位置（左闭右开）
🤔在上述方法中，只要是对字符串进行了操作的，原字符串仍然保持不变，最终生成的结果是通过return的形式返回，所以对字符串操作的方法的返回值都是String类型的（再次注意字符串的不变性）
boolean endsWith(String suffix) 测试此字符串是否以指定的后缀结束
boolean startsWith(String prefic) 测试字符串是否以指定的前缀开始
boolean startsWith(String prefic，int toffset) 测试此字符串从指定位置开始的子串是否以指定的前缀开始
boolean contains（CharSequence s）当前字符串中是否包含字符序列s，CharSequence 是一个字符序列接口（典型的实现类是String,StringBuffer,StringBuilder）， 此处可以传入一个String，但不能是字符数组
int indexOf(String str) 返回指定字符串在此字符串中第一次出现的索引位置
int indexOf(String str, int fromIndex) 返回指定字符串在此字符串中从fromIndex开始第一次出现的索引位置（可以用来寻找当前字符串中str出现的次数）
int lastIndexOf(String str) 返回最右出现的索引位置
int lastIndexOf(String str, int fromIndex) 返回最右出现的索引位置,从指定的索引开始反向搜索（从index开始向左搜索，如果index指的位置正好是最后一次出现的位置，则返回index）
String replace(char oldChar, char newChar) 返回一个新的字符串，它是通过用newchar替换此字符串中出现的所有oldChar得到的
String replace(CharSequence target, CharSequence replacement) 返回一个新的字符串，使用指定的字符序列替换此字符串中所有匹配的字符序列
String replaceAll(String regex, String replacement) 使用给定的replacement替换此字符串中所有匹配给定正则表达式的子字符串
String replaceFirst(String regex, String replacement) 使用给定的replacement替换此字符串中匹配给定正则表达式的第一个子字符串
boolean matches(String regex) 判断此字符串是否匹配给定的正则表达式
String[] split(String regex) 根据给定正则表达式的匹配拆分此字符串（符合正则表达式的部分不出现在最终结果中）
String[] split(String regex, int limit) 根据给定正则表达式的匹配拆分此字符串，最多不超过limit个，如果超过了剩下的全部放在最后一个元素中
String test="hhh,fff,ggg,aaa,ddd,eee,rrrr";
String[] res=test.split(",");
for(int i=0;i 基本数据类型/包装类 ：包装类.parseXXX()
(以int为例)
(好像valueOf方法都是把形参转换成当前类对象的)
public class StringTest1 {
@Test
public void test1(){
//int转String
int a=123;
String str1=String.valueOf(a);
String str2=""+a;
System.out.println(str1);
System.out.println(str2);
//String转int
int b=Integer.parseInt(str1);
System.out.println(b);
}
}
public void getChars(int start,int end,char c[],int offset)
该方法的作用是将当前字符串从start到end-1位置上的字符复制到字符数组c中，并从c的offset处开始存放
String与char[]的转换
String --> char[] : toCharArray()
char[] --> String : 构造器
@Test
public void test2(){
//string to char[]
String str="asf";
char[] chars=str.toCharArray();
for(int i=0;i byte[] : getBytes()
byte[] --> String : 构造器
@Test
public void test3(){
//String to byte[]
String str="123abc中国";
byte[] bytes_utf8=str.getBytes();
for(int i=0;i |